home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / mactcp / tcpglue.c < prev    next >
Text File  |  1995-01-18  |  10KB  |  478 lines
  1. /*
  2.  * Glue routines for mactcp module.
  3.  * Jack Jansen, CWI, 1994.
  4.  *
  5.  * Adapted from mactcp socket library, which was in turn
  6.  * adapted from ncsa telnet code.
  7.  *
  8.  * Original authors: Tom Milligan, Charlie Reiman
  9.  */
  10.  
  11. # include <Memory.h>
  12. # include <Files.h>
  13. # include <Errors.h>
  14.  
  15. #include "tcpglue.h"
  16. #include <Devices.h>
  17.  
  18. static short driver = 0;
  19.  
  20. #ifndef __powerc
  21. /*
  22.  * Hack fix for MacTCP 1.0.X bug
  23.  *
  24.  * This hack doesn't work on the PPC. But then, people with new machines
  25.  * shouldn't run ancient buggy software. -- Jack.
  26.  */
  27.  
  28. pascal char *ReturnA5(void) = {0x2E8D};
  29. #endif /* !__powerc */
  30.  
  31. OSErr xOpenDriver() 
  32. { 
  33.     if (driver == 0) 
  34.     { 
  35.         ParamBlockRec pb; 
  36.         OSErr io; 
  37.         
  38.         pb.ioParam.ioCompletion = 0L; 
  39.         pb.ioParam.ioNamePtr = "\p.IPP"; 
  40.         pb.ioParam.ioPermssn = fsCurPerm; 
  41.         io = PBOpen(&pb,false); 
  42.         if (io != noErr) 
  43.             return(io); 
  44.         driver = pb.ioParam.ioRefNum; 
  45.     }
  46.     return noErr;
  47. }
  48.  
  49. /*
  50.  * create a TCP stream
  51.  */
  52. OSErr xTCPCreate(buflen,notify,udp, pb) 
  53.     int buflen;
  54.     TCPNotifyUPP notify;
  55.     void *udp;
  56.     TCPiopb *pb;
  57. {    
  58.     pb->ioCRefNum = driver;
  59.     pb->csCode = TCPCreate;
  60.     pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
  61.     pb->csParam.create.rcvBuffLen = buflen;
  62.     pb->csParam.create.notifyProc = notify;
  63.     pb->csParam.create.userDataPtr = udp;
  64.     return (xPBControlSync(pb));
  65. }
  66.  
  67.  
  68. /*
  69.  * start listening for a TCP connection
  70.  */
  71. OSErr xTCPPassiveOpen(TCPiopb *pb, short port, TCPIOCompletionUPP completion,
  72.     void *udp)
  73. {
  74.     if (driver == 0)
  75.         return(invalidStreamPtr);
  76.  
  77.     pb->ioCRefNum = driver;
  78.     pb->csCode = TCPPassiveOpen;
  79.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  80.     pb->csParam.open.ulpTimeoutValue = 255 /* seconds */;
  81.     pb->csParam.open.ulpTimeoutAction = 0 /* 1:abort 0:report */;
  82.     pb->csParam.open.commandTimeoutValue = 0 /* infinity */;
  83.     pb->csParam.open.remoteHost = 0;
  84.     pb->csParam.open.remotePort = 0;
  85.     pb->csParam.open.localHost = 0;
  86.     pb->csParam.open.localPort = port;
  87.     pb->csParam.open.dontFrag = 0;
  88.     pb->csParam.open.timeToLive = 0;
  89.     pb->csParam.open.security = 0;
  90.     pb->csParam.open.optionCnt = 0;
  91.     pb->csParam.open.userDataPtr = udp;
  92.     return (xPBControl(pb,completion));
  93. }
  94.  
  95. /*
  96.  * connect to a remote TCP
  97.  */
  98. OSErr xTCPActiveOpen(TCPiopb *pb, short port, long rhost, short rport, 
  99.     TCPIOCompletionUPP completion)
  100. {
  101.     if (driver == 0)
  102.         return(invalidStreamPtr);
  103.  
  104.     pb->ioCRefNum = driver;
  105.     pb->csCode = TCPActiveOpen;
  106.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  107.     pb->csParam.open.ulpTimeoutValue = 60 /* seconds */;
  108.     pb->csParam.open.ulpTimeoutAction = 1 /* 1:abort 0:report */;
  109.     pb->csParam.open.commandTimeoutValue = 0;
  110.     pb->csParam.open.remoteHost = rhost;
  111.     pb->csParam.open.remotePort = rport;
  112.     pb->csParam.open.localHost = 0;
  113.     pb->csParam.open.localPort = port;
  114.     pb->csParam.open.dontFrag = 0;
  115.     pb->csParam.open.timeToLive = 0;
  116.     pb->csParam.open.security = 0;
  117.     pb->csParam.open.optionCnt = 0;
  118.     return (xPBControl(pb,completion));
  119. }
  120.  
  121. OSErr xTCPNoCopyRcv(pb,rds,rdslen,timeout,completion) 
  122.     TCPiopb *pb;
  123.     rdsEntry *rds; 
  124.     int rdslen;
  125.     int    timeout;
  126.     TCPIOCompletionUPP completion;
  127. {
  128.     
  129.     if (driver == 0)
  130.         return(invalidStreamPtr);
  131.     
  132.     pb->ioCRefNum = driver;
  133.     pb->csCode = TCPNoCopyRcv;
  134.     pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
  135.     pb->csParam.receive.rdsPtr = (Ptr)rds;
  136.     pb->csParam.receive.rdsLength = rdslen;
  137.     return (xPBControl(pb,completion));
  138. }
  139.  
  140. OSErr xTCPBufReturn(TCPiopb *pb,rdsEntry *rds,TCPIOCompletionUPP completion)
  141.     {
  142.     pb->ioCRefNum = driver;
  143.     pb->csCode = TCPRcvBfrReturn;
  144.     pb->csParam.receive.rdsPtr = (Ptr)rds;
  145.     
  146.     return (xPBControl(pb,completion));
  147.     }
  148.     
  149. /*
  150.  * send data
  151.  */
  152. OSErr xTCPSend(TCPiopb *pb, wdsEntry *wds, Boolean push, Boolean urgent, TCPIOCompletionUPP completion)
  153. {
  154.     if (driver == 0)
  155.         return invalidStreamPtr;
  156.     
  157.     pb->ioCRefNum = driver;
  158.     pb->csCode = TCPSend;
  159.     pb->csParam.send.validityFlags = timeoutValue | timeoutAction;
  160.     pb->csParam.send.ulpTimeoutValue = 60 /* seconds */;
  161.     pb->csParam.send.ulpTimeoutAction = 0 /* 0:abort 1:report */;
  162.     pb->csParam.send.pushFlag = push;
  163.     pb->csParam.send.urgentFlag = urgent;
  164.     pb->csParam.send.wdsPtr = (Ptr)wds;
  165.     return (xPBControl(pb,completion));
  166. }
  167.  
  168.  
  169. /*
  170.  * close a connection
  171.  */
  172. OSErr xTCPClose(TCPiopb *pb,TCPIOCompletionUPP completion) 
  173. {
  174.     if (driver == 0)
  175.         return(invalidStreamPtr);
  176.     
  177.     pb->ioCRefNum = driver;
  178.     pb->csCode = TCPClose;
  179.     pb->csParam.close.validityFlags = timeoutValue | timeoutAction;
  180.     pb->csParam.close.ulpTimeoutValue = 60 /* seconds */;
  181.     pb->csParam.close.ulpTimeoutAction = 1 /* 1:abort 0:report */;
  182.     return (xPBControl(pb,completion));
  183. }
  184.  
  185. /*
  186.  * abort a connection
  187.  */
  188. OSErr xTCPAbort(TCPiopb *pb) 
  189. {
  190.     if (driver == 0)
  191.         return(invalidStreamPtr);
  192.     
  193.     pb->ioCRefNum = driver;
  194.     pb->csCode = TCPAbort;
  195.     return (xPBControlSync(pb));
  196. }
  197.  
  198. /*
  199.  * close down a TCP stream (aborting a connection, if necessary)
  200.  */
  201. OSErr xTCPRelease(pb) 
  202.     TCPiopb *pb;
  203. {
  204.     OSErr io;
  205.     
  206.     if (driver == 0)
  207.         return(invalidStreamPtr);
  208.     
  209.     pb->ioCRefNum = driver;
  210.     pb->csCode = TCPRelease;
  211.     io = xPBControlSync(pb);
  212.     if (io == noErr)
  213.         DisposPtr(pb->csParam.create.rcvBuff); /* there is no release pb */
  214.     return(io);
  215. }
  216.  
  217. #if 0
  218.  
  219. int
  220. xTCPBytesUnread(sp) 
  221.     SocketPtr sp;
  222. {
  223.     TCPiopb    *pb;
  224.     OSErr io;
  225.     
  226.     if (!(pb = sock_fetch_pb(sp)))
  227.         return -1;        /* panic */
  228.     
  229.     if (driver == 0)
  230.         return(-1);
  231.     
  232.     pb->ioCRefNum = driver;
  233.     pb->csCode = TCPStatus;
  234.     io = xPBControlSync(pb);
  235.     if (io != noErr)
  236.         return(-1);
  237.     return(pb->csParam.status.amtUnreadData);
  238. }
  239.  
  240. int
  241. xTCPBytesWriteable(sp)
  242.     SocketPtr sp;
  243.     {
  244.     TCPiopb *pb;
  245.     OSErr    io;
  246.     long    amount;
  247.     
  248.     if (!(pb = sock_fetch_pb(sp)))
  249.         return -1;        /* panic */
  250.     
  251.     if (driver == 0)
  252.         return(-1);
  253.     
  254.     pb->ioCRefNum = driver;
  255.     pb->csCode = TCPStatus;
  256.     io = xPBControlSync(pb);
  257.     if (io != noErr)
  258.         return(-1);
  259.     amount = pb->csParam.status.sendWindow-pb->csParam.status.amtUnackedData;
  260.     if (amount < 0)
  261.         amount = 0;
  262.     return amount;
  263.     }
  264.     
  265. int xTCPWriteBytesLeft(SocketPtr sp)
  266.     {
  267.     TCPiopb *pb;
  268.     OSErr    io;
  269.     
  270.     if (!(pb = sock_fetch_pb(sp)))
  271.         return -1;        /* panic */
  272.     
  273.     if (driver == 0)
  274.         return(-1);
  275.     
  276.     pb->ioCRefNum = driver;
  277.     pb->csCode = TCPStatus;
  278.     io = xPBControlSync(pb);
  279.     if (io != noErr)
  280.         return(-1);
  281.     return (pb->csParam.status.amtUnackedData);
  282.     }
  283. #endif
  284.  
  285. OSErr xTCPStatus(TCPiopb *pb, TCPStatusPB **spb)
  286.     {
  287.     OSErr io;
  288.     
  289.     if (driver == 0)
  290.         return(-1);
  291.     
  292.     pb->ioCRefNum = driver;
  293.     pb->csCode = TCPStatus;
  294.     io = xPBControlSync(pb);
  295.     if (io == noErr)
  296.         *spb = &pb->csParam.status;
  297.     return(io);
  298.     }
  299.  
  300.  
  301. /*
  302.  * create a UDP stream, hook it to a socket.
  303.  */
  304. OSErr xUDPCreate(UDPiopb *pb,int buflen,ip_port *port, UDPNotifyUPP asr, void *udp)
  305.     {    
  306.     OSErr   io;
  307.     
  308.     pb->ioCRefNum = driver;
  309.     pb->csCode = UDPCreate;
  310.     pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
  311.     pb->csParam.create.rcvBuffLen = buflen;
  312.     pb->csParam.create.notifyProc = asr;
  313.     pb->csParam.create.userDataPtr = udp;
  314.     pb->csParam.create.localPort = *port;
  315.     if ( (io = xPBControlSync( (TCPiopb *)pb ) ) != noErr)
  316.         return io;
  317.         
  318.     *port = pb->csParam.create.localPort;
  319.     return noErr;
  320.     }
  321.  
  322. /*
  323.  * ask for incoming data
  324.  */
  325. OSErr xUDPRead(UDPiopb *pb, int timeout, UDPIOCompletionUPP completion) 
  326.     {
  327.     
  328.     if (driver == 0)
  329.         return(invalidStreamPtr);
  330.     
  331.     pb->ioCRefNum = driver;
  332.     pb->csCode = UDPRead;
  333.     pb->csParam.receive.timeOut = timeout;
  334.     pb->csParam.receive.secondTimeStamp = 0/* must be zero */;
  335.     return (xPBControl ( (TCPiopb *)pb, (TCPIOCompletionUPP)completion ));
  336.     }
  337.  
  338. OSErr xUDPBfrReturn(UDPiopb *pb, char *buff) 
  339.     {
  340.     
  341.     if (driver == 0)
  342.         return(invalidStreamPtr);
  343.     
  344.     pb->ioCRefNum = driver;
  345.     pb->csCode = UDPBfrReturn;
  346.     pb->csParam.receive.rcvBuff = buff;
  347.     return ( xPBControl( (TCPiopb *)pb,(TCPIOCompletionUPP)-1 ) );
  348.     }
  349.  
  350. /*
  351.  * send data
  352.  */
  353. OSErr xUDPWrite(UDPiopb    *pb,ip_addr host,ip_port port,miniwds *wds,
  354.         UDPIOCompletionUPP completion) 
  355.     {
  356.         
  357.     if (driver == 0)
  358.         return(invalidStreamPtr);
  359.     
  360.     pb->ioCRefNum = driver;
  361.     pb->csCode = UDPWrite;
  362.     pb->csParam.send.remoteHost = host;
  363.     pb->csParam.send.remotePort = port;
  364.     pb->csParam.send.wdsPtr = (Ptr)wds;
  365.     pb->csParam.send.checkSum = true;
  366.     pb->csParam.send.sendLength = 0/* must be zero */;
  367.     return (xPBControl( (TCPiopb *)pb, (TCPIOCompletionUPP)completion));
  368.     }
  369.  
  370. /*
  371.  * close down a UDP stream (aborting a read, if necessary)
  372.  */
  373. OSErr xUDPRelease(UDPiopb *pb) {
  374.     OSErr io;
  375.  
  376.     if (driver == 0)
  377.         return(invalidStreamPtr);
  378.     
  379.     pb->ioCRefNum = driver;
  380.     pb->csCode = UDPRelease;
  381.     io = xPBControlSync( (TCPiopb *)pb );
  382.     if (io == noErr) {
  383.         DisposPtr(pb->csParam.create.rcvBuff);
  384.         }
  385.     return(io);
  386.     }
  387.  
  388. ip_addr xIPAddr(void) 
  389. {
  390.     struct GetAddrParamBlock pbr;
  391.     OSErr io;
  392.     
  393.     pbr.ioCRefNum = driver;
  394.     pbr.csCode = ipctlGetAddr;
  395.     io = xPBControlSync( (TCPiopb *)&pbr );
  396.     if (io != noErr)
  397.         return(0);
  398.     return(pbr.ourAddress);
  399. }
  400.  
  401. long xNetMask() 
  402. {
  403.     struct GetAddrParamBlock pbr;
  404.     OSErr io;
  405.     
  406.     pbr.ioCRefNum = driver;
  407.     pbr.csCode = ipctlGetAddr;
  408.     io = xPBControlSync( (TCPiopb *)&pbr);
  409.     if (io != noErr)
  410.         return(0);
  411.     return(pbr.ourNetMask);
  412. }
  413.  
  414. unsigned short xMaxMTU()
  415. {
  416.     struct UDPiopb pbr;
  417.     OSErr io;
  418.     
  419.     pbr.ioCRefNum = driver;
  420.     pbr.csCode = UDPMaxMTUSize;
  421.     pbr.csParam.mtu.remoteHost = xIPAddr();
  422.     io = xPBControlSync( (TCPiopb *)&pbr );
  423.     if (io != noErr)
  424.         return(0);
  425.     return(pbr.csParam.mtu.mtuSize);
  426. }
  427.  
  428. OSErr xPBControlSync(TCPiopb *pb) 
  429. { 
  430.     (pb)->ioCompletion = 0L; 
  431.     return PBControl((ParmBlkPtr)(pb),false); 
  432. }
  433.  
  434. #pragma segment SOCK_RESIDENT
  435.  
  436. OSErr xTCPRcv(pb,buf,buflen,timeout,completion) 
  437.     TCPiopb *pb;
  438.     Ptr buf; 
  439.     int buflen;
  440.     int    timeout;
  441.     TCPIOCompletionUPP completion;
  442. {
  443.     
  444.     if (driver == 0)
  445.         return(invalidStreamPtr);
  446.     
  447.     pb->ioCRefNum = driver;
  448.     pb->csCode = TCPRcv;
  449.     pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
  450.     pb->csParam.receive.rcvBuff = buf;
  451.     pb->csParam.receive.rcvBuffLen = buflen;
  452.     return (xPBControl(pb,completion));
  453. }
  454.  
  455. OSErr xPBControl(TCPiopb *pb,TCPIOCompletionUPP completion) 
  456. { 
  457. #ifndef __MWERKS__
  458.     pb->ioNamePtr = ReturnA5();
  459. #endif
  460.     
  461.     if (completion == 0L) 
  462.     { 
  463.         (pb)->ioCompletion = 0L; 
  464.         return(PBControl((ParmBlkPtr)(pb),false));        /* sync */
  465.     } 
  466.     else if (completion == (TCPIOCompletionUPP)-1L) 
  467.     { 
  468.         (pb)->ioCompletion = 0L; 
  469.         return(PBControl((ParmBlkPtr)(pb),true));        /* async */
  470.     } 
  471.     else 
  472.     {  
  473.         (pb)->ioCompletion = completion;
  474.         return(PBControl((ParmBlkPtr)(pb),true));        /* async */
  475.     } 
  476. }
  477.  
  478.